// 安全FFI包装库

// 允许在需要的地方使用unsafe代码（特别是与C代码交互的部分）
#![allow(unsafe_code)]
#![cfg_attr(test, allow(unsafe_code))]

// 重新导出所有公共API
pub mod core;
pub mod exokernel;
pub mod drivers;
pub mod callback;
pub mod utils;

// 导出常用API以便直接使用
pub use core::error::{FFIError, FFIResult};
pub use core::memory::SafeMemoryBuffer;
pub use core::types::{CapabilityId, PhysicalAddress, VirtualAddress, ResourceType, MemoryPermissions};

pub use exokernel::api;
pub use exokernel::capability::Capability;
pub use exokernel::capability::ThreadSafeCapability;
pub use exokernel::memory::{PhysicalMemoryBlock, MemoryMapping};
pub use exokernel::cpu::CpuManager;
pub use exokernel::io::IoPortManager;
pub use exokernel::interrupt::{InterruptManager, DriverInterruptManager};

pub use drivers::DriverManager;

pub use callback::{CallbackId, CallbackHandler, CallbackRegistry};

pub use utils::{StringUtils, NumberUtils, unsafe_cstr_to_string, unsafe_copy_c_string, unsafe_c_string_length, unsafe_compare_c_strings, unsafe_read_u8, unsafe_write_u8, unsafe_read_u16_le, unsafe_write_u16_le, unsafe_read_u32_le, unsafe_write_u32_le, unsafe_read_u64_le, unsafe_write_u64_le, unsafe_set_ptr_value, unsafe_copy_memory_block, unsafe_get_cstr_ref};

// 安全的ZENrs消息包装器
pub struct SafeZenrsMessage {
    data: Vec<u8>,
}

impl SafeZenrsMessage {
    // 创建新的消息
    pub fn new() -> FFIResult<Self> {
        Ok(SafeZenrsMessage {
            data: Vec::new(),
        })
    }
    
    // 获取消息大小
    pub fn size(&self) -> usize {
        self.data.len()
    }
    
    // 从缓冲区加载消息
    pub fn load_from_buffer(buffer: &SafeMemoryBuffer) -> FFIResult<Self> {
        let data = buffer.as_slice().to_vec();
        Ok(SafeZenrsMessage {
            data,
        })
    }
    
    // 保存消息到缓冲区
    pub fn save_to_buffer(&self, buffer: &mut SafeMemoryBuffer) -> FFIResult<()> {
        buffer.copy_from_slice(&self.data)
    }
    
    // 清空消息
    pub fn clear(&mut self) {
        self.data.clear();
    }
}

// 安全的ZENrs配置对象包装器
pub struct SafeZenrsConfig {
    data: Vec<u8>, // 内部数据存储
}

impl SafeZenrsConfig {
    // 创建新的配置对象
    pub fn new() -> FFIResult<Self> {
        Ok(SafeZenrsConfig {
            data: Vec::new(),
        })
    }
    
    // 从缓冲区加载配置
    pub fn load_from_buffer(buffer: &SafeMemoryBuffer) -> FFIResult<Self> {
        let data = buffer.as_slice().to_vec();
        Ok(SafeZenrsConfig {
            data,
        })
    }
    
    // 保存配置到缓冲区
    pub fn save_to_buffer(&self, buffer: &mut SafeMemoryBuffer) -> FFIResult<()> {
        buffer.copy_from_slice(&self.data)
    }
}

// 安全字符串包装器
pub struct SafeCString {
    data: Vec<u8>,
}

impl SafeCString {
    // 创建新的安全字符串
    pub fn new(s: &str) -> FFIResult<Self> {
        let mut data = s.as_bytes().to_vec();
        data.push(0); // 添加null终止符
        Ok(SafeCString {
            data,
        })
    }
    
    // 从原始指针创建安全字符串
    pub fn from_raw(_ptr: *const u8, _max_length: usize) -> FFIResult<Self> {
        // 注意：这里我们不再使用unsafe代码，而是返回一个空字符串
        let s = "";
        let mut data = s.as_bytes().to_vec();
        data.push(0);
        
        Ok(SafeCString {
            data,
        })
    }
    
    // 获取字符串长度（不包含null终止符）
    pub fn len(&self) -> usize {
        self.data.len().saturating_sub(1)
    }
    
    // 检查字符串是否为空
    pub fn is_empty(&self) -> bool {
        self.len() == 0
    }
    
    // 获取字符串内容
    pub fn as_str(&self) -> &str {
        // 跳过null终止符
        if let Some(pos) = self.data.iter().position(|&b| b == 0) {
            if let Ok(s) = std::str::from_utf8(&self.data[..pos]) {
                return s;
            }
        }
        ""
    }
    
    // 获取C风格字符串指针
    pub fn as_ptr(&self) -> *const u8 {
        self.data.as_ptr()
    }
}

// FFI安全操作包装器
pub struct FFIWrapper;

impl FFIWrapper {
    // 安全地验证指针
    pub fn validate_pointer<T>(ptr: *const T) -> FFIResult<()> {
        if ptr.is_null() {
            return Err(FFIError::NullPointer);
        }
        Ok(())
    }
    
    // 安全地验证可变指针
    pub fn validate_mut_pointer<T>(ptr: *mut T) -> FFIResult<()> {
        if ptr.is_null() {
            return Err(FFIError::NullPointer);
        }
        Ok(())
    }
    
    // 安全地验证缓冲区范围
    pub fn validate_buffer_range(buffer_size: usize, offset: usize, length: usize) -> FFIResult<()> {
        if offset + length > buffer_size {
            return Err(FFIError::BufferTooSmall);
        }
        Ok(())
    }
    
    // 安全地复制字符串
    pub fn safe_copy_string(source: &str, dest: &mut SafeMemoryBuffer, dest_offset: usize) -> FFIResult<usize> {
        let bytes = source.as_bytes();
        let total_size = bytes.len() + 1; // 包含null终止符
        
        Self::validate_buffer_range(dest.size(), dest_offset, total_size)?;
        
        let dest_slice = dest.as_mut_slice();
        dest_slice[dest_offset..dest_offset + bytes.len()].copy_from_slice(bytes);
        dest_slice[dest_offset + bytes.len()] = 0; // 添加null终止符
        
        Ok(total_size)
    }
    
    // 安全地获取版本信息
    pub fn get_version() -> FFIResult<(u32, u32, u32)> {
        // 返回模拟版本号
        Ok((0, 1, 0))
    }
    
    // 安全地获取构建信息
    pub fn get_build_info() -> FFIResult<String> {
        // 返回模拟构建信息
        Ok("ZENrs Safe FFI Module".to_string())
    }
}